package service

import (
	"fmt"
	"g_ansible/ansible/model"
	"g_ansible/global"
	"strconv"
	"strings"
)

type HostService struct {
}

func (b *HostService) Query() []model.V1Group {
	cfg := global.Ini
	// 遍历所有节(sections)
	//var Ini model.Ini
	var group []model.V1Group
	for _, section := range cfg.Sections() {
		var tmpgroup model.V1Group
		sectionName := section.Name()
		// 跳过默认节
		if sectionName == "DEFAULT" {
			continue
		}

		section := cfg.Section(sectionName)
		for _, i3 := range section.Keys() {
			//testhost
			//ansible_host=192.168.1.100 ansible_port=22 ansible_ssh_user=root ansible_ssh_pass=testpass
			var tmpHost model.Host
			//主机别名
			tmpHost.Alias = i3.Name()
			//IP地址
			s2 := strings.Split(i3.Value(), " ")

			// 解析 ansible_host
			if len(s2) > 0 {
				p := strings.Split(s2[0], "=")
				if len(p) > 1 {
					tmpHost.AnsibleHost = p[1]
				}
			}

			// 检查是否有足够的元素来解析端口
			if len(s2) > 1 {
				//端口号
				p := strings.Split(s2[1], "=")
				if len(p) > 1 {
					atoi, err := strconv.Atoi(p[1])
					if err != nil {
						// 如果转换失败，使用默认端口22
						tmpHost.AnsiblePort = 9999
					} else {
						tmpHost.AnsiblePort = atoi
					}
				} else {
					// 如果分割后没有等号，使用默认端口22
					tmpHost.AnsiblePort = 9999
				}
			} else {
				// 如果没有端口配置，使用默认端口22
				tmpHost.AnsiblePort = 22
			}

			// 检查是否有足够的元素来解析ssh用户
			if len(s2) > 2 {
				//ssh用户
				su := strings.Split(s2[2], "=")
				if len(su) > 1 {
					tmpHost.AnsibleSshUser = su[1]
				} else {
					// 如果没有等号，使用默认用户
					tmpHost.AnsibleSshUser = "root"
				}
			} else {
				// 如果没有用户配置，使用默认用户
				tmpHost.AnsibleSshUser = "root"
			}

			// 检查是否有足够的元素来解析ssh密码
			if len(s2) > 3 {
				//密码
				sp := strings.Split(s2[3], "=")
				if len(sp) > 1 {
					tmpHost.AnsibleSshPass = sp[1]
				} else {
					// 如果没有等号，使用空密码
					tmpHost.AnsibleSshPass = ""
				}
			} else {
				// 如果没有密码配置，使用空密码
				tmpHost.AnsibleSshPass = ""
			}

			tmpgroup.Name = sectionName
			tmpgroup.Host = append(tmpgroup.Host, tmpHost)
		}
		group = append(group, tmpgroup)
		//Ini.Group = group
	}

	//for _, v := range group {
	//	fmt.Println("主机组", v.Name)
	//	for _, v := range v.Host {
	//		fmt.Println("主机别名:", v.Alias)
	//		fmt.Println("IP地址:", v.AnsibleHost)
	//		fmt.Println("端口号:", v.AnsiblePort)
	//		fmt.Println("ssh用户:", v.AnsibleSshUser)
	//		fmt.Println("ssh密码:", v.AnsibleSshPass)
	//	}
	//}

	return group
}

func (b *HostService) Add(g model.V1Group) error {
	//查询分组是否存在
	cfg := global.Ini
	//分组存在
	if !cfg.HasSection(g.Name) {
		//拼接字符串
		//name1 ansible_host
		//192.168.84.200 ansible_port=22 ansible_ssh_user=root ansible_ssh_pass=Lvshicong990!
		//分组不存在
		_, err := cfg.NewSection(g.Name)
		if err != nil {
			return fmt.Errorf("创建section失败:%s", err)
		}
	}
	err := i(g)
	if err != nil {
		return err
	}
	return nil
}

func (b *HostService) Delete(groupName, hostAlias string) error {
	// 查询分组是否存在
	cfg := global.Ini
	if !cfg.HasSection(groupName) {
		return fmt.Errorf("主机组 %s 不存在", groupName)
	}

	// 查询主机是否存在
	section := cfg.Section(groupName)
	keys := section.KeyStrings()
	hostFound := false
	for _, key := range keys {
		// 主机别名在key的第一个空格分隔部分
		parts := strings.Split(key, " ")
		if len(parts) > 0 && parts[0] == hostAlias {
			hostFound = true
			break
		}
	}

	if !hostFound {
		return fmt.Errorf("主机 %s 在主机组 %s 中不存在", hostAlias, groupName)
	}

	// 删除主机
	section.DeleteKey(hostAlias)

	// 保存配置到文件
	err := cfg.SaveTo(global.Config.System.HostFile)
	if err != nil {
		return fmt.Errorf("保存文件失败:%s", err)
	}

	return nil
}

func i(g model.V1Group) error {
	cfg := global.Ini
	for _, host := range g.Host {
		val := "ansible_host=" + host.AnsibleHost + " " +
			"ansible_port=" + strconv.Itoa(host.AnsiblePort) + " " +
			"ansible_ssh_user=" + host.AnsibleSshUser + " " +
			"ansible_ssh_pass=" + host.AnsibleSshPass
		k := host.Alias
		_, err := cfg.Section(g.Name).NewKey(k, val)
		if err != nil {
			return fmt.Errorf("创建key失败:%s", err)
		}
		// 保存配置到文件
		err = cfg.SaveTo(global.Config.System.HostFile)
		if err != nil {
			return fmt.Errorf("保存文件失败:%s", err)
		}
	}
	return nil
}

func (b *HostService) IsHostExist(newGroup model.V1Group) bool {
	cfg := global.Ini

	// 检查分组是否存在
	if !cfg.HasSection(newGroup.Name) {
		return false
	}

	section := cfg.Section(newGroup.Name)

	// 遍历要添加的主机
	for _, newHost := range newGroup.Host {
		// 检查该主机是否已存在
		keys := section.KeyStrings()
		for _, key := range keys {
			// 解析现有的主机配置
			parts := strings.Split(key, " ")
			if len(parts) > 0 && parts[0] == newHost.Alias {
				// 找到相同别名的主机，进一步比较详细配置
				existingKey := section.Key(key)
				existingValue := existingKey.Value()

				// 构造新主机的配置字符串用于比较
				newHostValue := "ansible_host=" + newHost.AnsibleHost + " " +
					"ansible_port=" + strconv.Itoa(newHost.AnsiblePort) + " " +
					"ansible_ssh_user=" + newHost.AnsibleSshUser + " " +
					"ansible_ssh_pass=" + newHost.AnsibleSshPass

				// 比较配置是否完全相同
				if existingValue == newHostValue {
					return true
				}
			}
		}
	}

	return false
}
